I would have opened an issue first but some ideas and benefits are easier to demonstrate as a PR and working example, so here goes…

This PR primarily separates the diff algorithm from supporting types ListDiffAction<,>, ListDiffActionType and ListDiff<,> and renders it even more generic so that it can stand and be used on its own; this leads to many benefits.

First and foremost, the core function becomes very generic:

List<R> Diff<S, D, R> (IEnumerable<S> source, IEnumerable<D> destination,
                       Func<S, D, bool> match,
                       Func<S, D, R> updateResult,
                       Func<D, R> addResult,
                       Func<S, R> removeResult,
                       out bool containsOnlyUpdates)

The 3 functions updateResult, addResult and removeResult project the result elements such that the function can return a simple list (List<>) of those results. The shape of R is now up to the caller based on relevant inputs.

The constructor of ListDiff<,> has been updated to use it as follows:

Actions = Diff (source, destination, match,
                (s, d) => new ListDiffAction<S, D> (ListDiffActionType.Update, s, d),
                d      => new ListDiffAction<S, D> (ListDiffActionType.Add, default, d),
                s      => new ListDiffAction<S, D> (ListDiffActionType.Remove, s, default),
                out var containsOnlyUpdates)

The are several other overloads added for convenience. For example, when source and destination elements are the same some type T then you get a simpler signature:

List<R> Diff<T, R> (IEnumerable<T> source, IEnumerable<T> destination,
                    Func<T, T, R> updateResult,
                    Func<T, R> addResult,
                    Func<T, R> removeResult,
                    out bool containsOnlyUpdates)

This uses the default comparer (EqualityComparer<T>.Default) so a function to determine a match isn't needed. This also solves the boxing/performance problem highlighted in issue #8.

Since we have tuples, we can go one step further for simpler scenarios with the following signature:

List<(A, S, D)> Diff<S, D, A> (IEnumerable<S> source, IEnumerable<D> destination,
                               Func<S, D, bool> match,
                               A update, A add, A remove,
                               out bool containsOnlyUpdates) =>

That is, given 3 tags to represent an update, add or remove node, the function will return a list of triplets where the source and destinations elements are annotated with the appropriate tag.

In its current design, the stand-alone Diff method is part of a class called DiffModule. This permits using the method directly via a static import (using static ListDiff.DiffModule).

I have also placed DiffModule in its own file and made the definition partial and private by default. Then in ListDiff.cs, the partial definition has the public modifier to make it public. The idea behind this seemingly bizarre approach is that it enables someone to just take Diff.cs and run with it in their project without inheriting any dependencies or types of the project. DiffModule will automatically become a private artifact of the user's project. However, when included together with ListDiff.cs as part of this project, it is exposed publicly.

If you like what you see here, I am happy to put polishing touches like doc comments and argument validation.

Looking forward to your review and thoughts.